#include <iostream>
using namespace std;
//继承方式

class Base {
public:
	int m_a = 0;
	static int sta;
protected:
	int m_b = 0;
private:
	int m_c = 0;
};

int Base::sta = 10;

//公有继承---public
class son1 :public Base {
public:
	void func()
	{
		m_a = 100;  //父类中的公共权限成员 到子类中依然是公共权限
		m_b = 100;  //父类中的保护权限成员 到子类中依然是保护权限
		sta = 1000; //父类中公共静态成员   到子类中依然是公共静态成员
 		//m_c = 100; 所以public继承下来的私有变量是不可访问
		cout << "&sta=" << &sta << endl;
	}
};

void test()
{
	son1 s;
	s.m_a = 1000;  //依然可以访问 证明了他是公共权限成员
	s.sta = 1000;
	//s.m_b = 1000;  //m_b 是保护权限成员
}

//保护继承 protected
class son2 : protected Base {
public:
	void func()
	{
		m_a = 1000;  //父类中公共权限成员 到子类中是保护权限
		m_b = 1000;  //父类中保护权限成员 到子类中是保护权限
		sta = 10000; //父类中公共静态成员 到子类中是保护静态成员
		//m_c = 1000;所以protected继承下来的私有变量是不可访问
		cout << "&sta=" << &sta << endl;

	}
};

void test2()
{
	son2 s2;
	//s2.sta = 10000 //不可以被访问的
	//s2.m_a = 10000; //继承下来的保护成员函数在类内能访问，在类外不能访问
	//s2.m_b = 10000; // 也是保护成员
}


//私有继承 private
class son3 :private Base {
public:
	void func()
	{
		m_a = 1000;   //父类中的私有权限成员，到子类中私有权限
		m_b = 1000;   //父类中的保护权限成员 到子类中私有权限
		sta = 100000; //父类中的公共静态成员 到子类中私有静态成员
		//m_c = 100;  //private 继承下来的私有变量是不可访问的
		cout << "&sta=" << &sta << endl;

	}
};

class granson3 :public son3 {
public:
	void func()
	{
		//m_a = 1000;  //
		//sta = 10000;  //不可以被访问

	}
};

void test3()
{
	son3 s3;
	//s3.sta = 100; //不可访问
	//s3.m_a = 1000; //

}


int main()
{
   //test();
   son1 s1;
   son2 s2;
   son3 s3;
   Base b;
   //cout << "sizeof Base " << sizeof b << "  sizeof son1 " << sizeof s1 << "  sizeof son2 " << sizeof s2 << " sizeof son3" << sizeof s3 << endl;
   s1.func();
   s2.func();
   s3.func();

   return 0;
}


